{Documentation for Barfly

{

Kleiner Hellweg 4 D-33154 Salzkotten Germany Internet: laire@uni-paderborn.de IRC: laire

{

{Version 1.0

Barfly 1.0

An Intuition controlled Debugger and Optimizing Assembler

Copyright (c) 1989-94 Ralph Schmidt

- Shareware -

Chapters for ‘all’ users…

Introduction…

Using BDebug…

Using BAsm…

Includes & Linker…

Other topics…

1 Basic Informations

1.1 Copyright and other legal stuff

Copyright (c) 1989-94 Ralph Schmidt

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

No guarantee of any kind is given that the programs described in this document are 100% reliable. You are using this material at your own risk. The author can not be made responsible for any damage which is caused by using these programs.

Permission is granted to include this package in Public-Domain collections, especially in Fred Fishs Amiga Disk Library (including CD-ROM versions of it). The distribution file may be uploaded to Bulletin Board Systems or FTP servers. If you want to distribute this program you must use the original distribution archive ‘Barfly.lha’.

None of the programs may be included or used in commercial programs unless by written permission from the author.

None of the programs may be modified in any way. This especially includes changing the copyright notices or removing any of the Shareware restrictions.

None of the programs may be used on any machine which is used for the research, development, construction, testing or production of weapons or other military applications. This also includes any machine which is used for training persons for any of the above mentioned purposes.

None of the programs may be used by more than the registrated owner.

1.2 Registration

As you may have noticed in the copyright I’m working for five years at Barfly. It has always consumed and will continue to consume a large amount of my time.

I cannot afford just working for fun. Thus, I decided to release Barfly as Shareware. I already tried to release Barfly as a commercial product but the story behind it is more than sad. To sum it…german Amiga software companys aren’t worth any time...‘they suck’. Some people may think the price is too high for a Shareware product but i think that BAsm is as powerful as the 2 main available commercial Assemblers…if not more powerful if you compare the speed and the optimize functions;there’s no commercial Debugger available that can compete with BDebug. I’ve used Barfly myself for commercial Amiga applications. Z3-Fastlane device,CDRive,SCSIConfig,...

The unregistered version of Barfly pops up the About requester at the start and has some functions disabled:

Assembler:
 o only 8192Bytes large code possible
 o the Section commands aren't available
Debugger:
 o Only 1 Window per Object
 o Enforcer Catch not available
 o Task Catch not available
 o Crashed Task Catch not available
 o Limited Step count(about 150-200 Steps)

Registered users will be shipped a disk with the newest public release of Barfly, along with a personalized, so-called “keyfile”. It enables all the missing features and disables the Shareware reminders. This keyfile will work with all future releases of Barfly, so you can simply download the latest version from your local bulletin board without having to wait weeks for your update passing through the slow mail channels. The keyfile ‘must not’ be distributed in any way.

The fee for a Barfly registration is

 70.- DM  (D-Mark),
 70.- SFr (Schweizer Franken),
230.- FF  (French Francs),
 50.- US$ (US Dollar)

The fastest, cheapest and easiest way to register is put the money together with the filled registration form into a letter and send it to

Please allow 2-5 weeks delivery for the registrated version.

Ralph Schmidt
Kleiner Hellweg 4
33154 Salzkotten
FR Germany
Phone: +49-5258-5637
E-Mail: laire@uni-paderborn.de
   Irc: Laire on #amiga,#amigager

2 Introduction

2.1 Purpose

BDebug is an Intuition controlled multi-task system Debugger for OS 2.04 and newer.

You can use BDebug to debugging your programs, catching tasks, reseach enforcer hits, follow Source-Level Informations and other advanced functions. The Debugger supports assemblers,SAS C,Dice and GCC.

Some of BDebug’s features are:

• font-sensitive, resizable and Style Guide compliant GadTools GUI
• Object-Oriented that results in a low learning curve
• Supports 68000…68060 and the FPUs
• Can debug multiple tasks at the same time
• Not limited by the amount of window objects.
• highly configurable
• keyboard support

BAsm is a very fast optimizing Assembler for OS 2.04 and newer.

Some of BAsm’s features are:

• 68000-68060,6888x
• Very Fast
• Include and Incbin Cache
• Strong Optimizer with Multi-Pass Optimizing
• High Level Macros
• ARexx
• Supports OS 2.04 and OS 3.0 Hunks
• SAS D1 Source Level Format

2.2 System requirements

Barfly requires Amiga operating system version 2.04 or better.

Kickstart 1.3 is not supported; this operating system is considered obsolete.

Barfly requires at least one megabyte of RAM to run. A hardisk or a faster CPU is not required but increase performances and comfort, of course.

2.3 Installation

It is really easy to install Barfly:

1. Copy the the binary and the icon (called “BDebug” and “BDebug.info”) to any directory.

2. Copy the the binary and the icon (called “BAsm” and “BAsm.info”) to any directory.

Then copy the supplied configuration files from “s/Barfly/#?” to “S:” directory of your system partition or create env:Barflypath with the path to a directory that contains Barfly/#?.

3 Other topics

3.1 Updates

Whenever a new release of Barfly gets released, I will post some information in the appropriate newsgroups of some electronic networks. The new archive will soon be available on many bulletin boards and on all ‘AmiNet’ FTP servers. Major releases will also come with some PD disks, especially on Fred Fish’s collection.

As mentioned above, registered users will neither need a new keyfile nor a special personalized program version. They can use all new features immediately.

3.2 Support

If you have some questions, comments, suggestions or even flames, please feel free to contact me at one of the following addresses. If you send your letter via e-mail, there’s a good chance for getting a quick reply.

Snailmail: Ralph Schmidt
           Kleiner Hellweg 4
           33154 Salzkotten
           FR Germany

    Phone: +49-5258-5637

  E-Mail: laire@uni-paderborn.de
      Irc: Laire on #amiga,#amigager

3.3 History

• 0.0 - 1.0
  not released

3.4 Future

Here are some ideas for future versions of BDebug:

• Full Source Level support for GCC and perhaps SAS.
• Better BDebug Arexx support…the current one is a bad excuse.
• Mungwall Trace methods.
• Automatic Refresh of some Windows(Task Window...)
• Amigaguide file mode in the autodocs functions.
• Highlight changed registers
• Better documentation.
• BAsmOption for the easy BAsm options configuration.
• Other things i’m too lazy to mention now.

Important:

There is absolutely NO guarantee that these features will ever be
implemented. So don't be disappointed, if they aren't in the next
version.

3.5 Acknowledegments

Thanks must go to:

• - Dirk Leschner, Frank Jakobs

  for being my best friends

• - Matthias Scheler

  for his manual design and Filer.

• - S.Schaem, Brge Nst, Alexis Wilke, Michael B. Smith, Marc Heuler

  for their superb betatesting efforts

• - Mike Schwartz

  for a lot suggestions to improve basm. Sad he has left the Amiga community 2 years ago.

• - Stefan Becker

  for Toolmanager and being a nice guy.

• - Christoph Wolf

  for DynamiCache and being a nice guy.

• - Brian Cerveny(Redwine)

  for Grapevine and being a nice guy(Really ?).

• - All my IRC friends.

  for many great hours. Thanks!

  Andrew Denton(Guardian), Kenneth Dyke(Nyx), Bill Coldwell(Cryo), Brian Cerveny(Redwine), Joseph Hillenburg(xterm), Scott Ellis(ScottE), Chris Wichura(Caw), John Wiederhirn(John\_W), Mike Schwartz(mykes), Markus Illenseer(ill), Petra Zeidler(stargazer), Michael van Elst(mlelstv), Holger Lubitz(holgi), Ralph Babel(rbabel), Seth Harman(Budha) and a lot guys i haven’t mentioned here.

• - Chris Schneider and Urban D. Mueller

  for some suggestions 2-3 years ago and installing Aminet.

• - Michael “billy” Bhnisch

  for his cleanup on MakeBarflyFD 2-3 years ago.

• - Steve Wright

  for designing the icons 2 years ago.

And of course to all the other Beta testers and registered users.

The V40 Includes can be ftp’ed from the FTP-Server.

ftp.rz.uni-wuerzburg.de: pub/amiga/frozenfish/bbs/com

A superb Linker "lk" by Alex Wilke should be soon availble on Aminet.

BDebug 1.0

An Intuition controlled Debugger

Copyright (c) 1989-94 Ralph Schmidt

- Shareware -

Using BDebug…

4 Usage of BDebug

4.1 The Command Window

4.2 Debugger Philosophy

BDebug is a multitasking Debugger that supports the Motorola processors 68000…68060 and 68881…68882. The Debugger allows to debug unlimited tasks parallel. Because of the Debugger’s complexity BDebug was designed in an object-oriented way to allow an easy and comfortable way to use it. The register window ‘REGWindow’ is the Root class of the task object that can be expanded by several subclass windows. Every subclass window has privat menus and inherits the public menus of its father object.

4.3 Debug Methoden

The Debugger offers a variety of different Debug methods that can be activated by menu or gadget.

4.3.0.1 Debug Task

is used to select a task you wanna debug. If you doubleclick on a task a ‘REGWindow’ and a couple of information windows opens. Which type and how many are opened depends on the current configuration. After the task could be stopped the contents of the ‘REGWindow’ and all other information windows gets refreshed. If the task is in the ‘Wait’ state the task is stopped when it gets a signal.

Task Listview Layout

Taskaddress & Priority & Status & [!]Name

A process is marked by ‘!’ at the beginning of the name.

You should know what task you can stop and what kind of task should never be stopped. For example the Input.device should never be stopped.

4.3.0.2 Debug File

is used to load and stop a program. This function is equal to the bdebug cli startup with the exception that you can enter the parameter in a requester. If no error occur all configurated windows are opened and the PC stops at the defined programstart breakpoint that normally points to the first command of the program.

4.3.0.3 Debug Next Task

is used to debug the next task that is opened. The Debugger waits until another task is created by AddTask and a couple of information windows opens. Which type and how many are opened depends on the current configuration. After the new task was caught the pc points to the beginning of the task and ‘Catch Next Task’ is disactivated. To catch a program that is started from the WV you have to use ‘Debug Next Task’ to catch the WB Startup Task ‘WBL’ that starts the program. Now you have to activate ‘Debug Next Task’ again and let the current task run. After a short time the task ‘WBL’ ends and the program’s task is caught.

You should avoid to start a new task between the 2 ‘Debug Next Task’ phases because it’s easy to catch the wrong one.

You should notice that ‘AddTask’ is patched and points to a new routine. Thus you should be careful with programs that also patch ‘AddTask’. Furthermore it’s useful know in what sequences these patches have to be removed. The Debugger can only be closed when all patched system function that were installed after the Debugger was started are removed.

If you start a program in the shell without ‘c:Run’ no new task is created. Instead the program is run as a subroutine in shell’s task so you can’t catch the task that easy.

4.3.0.4 Debug Crashed Task

is used to catch tasks that crash so you track down the bug location a lot easier. If the system itself doesn’t run anymore you shouldn’t expect that bdebug still runs because it depends on a working system. If a task crashes and the option ‘Debug Crashed Task’ is activated a couple of information windows opens. Which type and how many are opened depends on the current configuration. ‘Task Held Requester’.

4.3.0.5 Catch Enforcer Hit

is used to tell the Debugger to stop the task it controlls when an enforcer hit happens. Unfortunately the Debugger can’t stop the task at exactly the same location where the hit happened. Mostly the hit command is 1-2 instructions above the stopped task’s PC.

This function needs Enforcer V37.x by M. Sinz and it must be installed before BDebug is started. Please read the documentation.

4.3.0.6 Select Display Mode

This function allows you to chooce the Screen Mode for the Debugger.

4.4 How to start ?

If you only want to debug a program you have to start bdebug with the program’s name and parameters or by using ‘Debug Program’ in the command window. Another method is to move a program’s icon on the command window or specify BDebug as in the icon as the ‘DefaultTool’.

‘Name:’

BDEBUG - The CLI Startup

‘Synopnis:’

BDEBUG [?] [<Program> [Argument] ]

‘Function:’

BDebug activates the Debugger, loads and stops the optional entered program. If it can find a local config file with the suffix *.bdebug it loads it.

‘Inputs’

• ? shows an information message
• program name If no program name is entered BDebug looks for env:BDebugProgram and loads the program instead that the env: points to.
• argument line of the program. If there are spaces in parameters you have to enclose the argument with ‘""’.

5 Usage of BDebug

5.1 The Register Window

5.1.1 Register Window

The register window is the most important control layer of the Debugger and every debugged task has one. You can link unlimited other information windows to the ‘REGWindow’ or you can tell the Debugger to give up controlling the task. In the title line of the window you can see the ID number of the task, so you can recognize what information window belongs to this task. Furthermore the title line also contain the task address,the state, ‘RUN’,‘WAIT’ or ‘STOP’ and the name of the task. The task is in the ‘RUN’ state if the task has the controll at the moment instead of the traphandler; the task is in the ‘STOP’ state when the task waits and the traphandler controlls what happens. The task is the ‘WAIT’ state only when the Debugger has to wait to catch a task by a ‘Debug Task’. In the upper area of the window you see the normal data and address registers where the address register also have additional information fields. To change a register or to watch memory where the register points to you only need to doubleclick on the register or on the register’s memory contents. Furthermore you may change other usermode registers by this method. Supervisor register can’t be changed because that makes not much sense for a system Debugger.

‘68000 Registers’

D0=xxxxxxxx yyyy A0=xxxxxxxx Arg1 Arg2 [!]

D1=xxxxxxxx yyyy A1=xxxxxxxx Arg1 Arg2 [!]

D2=xxxxxxxx yyyy A2=xxxxxxxx Arg1 Arg2 [!]

D3=xxxxxxxx yyyy A3=xxxxxxxx Arg1 Arg2 [!]

D4=xxxxxxxx yyyy A4=xxxxxxxx Arg1 Arg2 [!]

D5=xxxxxxxx yyyy A5=xxxxxxxx Arg1 Arg2 [!]

D6=xxxxxxxx yyyy A6=xxxxxxxx Arg1 Arg2 [!]

D7=xxxxxxxx yyyy A7=xxxxxxxx Arg1 Arg2 [!]

USP=xxxxxxxx SSP=xxxxxxxx PC=xxxxxxxx SR=xxxx

• [!] shows if the address register points on an odd address.
• if the address register points on an illegal memory area the char ‘*’ is shown in Arg1 and Arg2 to avoid crashes by reading non readable io-addresses. You can config the readable memory areas.
• if the address register points on the following system structures the name of the Node is shown in Arg1 and the Name of the structure in Arg2.
  • Library
  • Device
  • Port
  • Task
  • Resource
  • MemHead
• if the address register points to the custom chip area the name of the register is shown in Arg1 and the ID-Word CUSTOM is shown in Arg2. Custom register map is $dff000-$dff200.
• if the address register points to a symbol the symbol and the contents is shown.
• Otherwise 8Bytes of the memory are shown where the register points to. The 8 Bytes are shown hexadecimal in Arg1 and ascii in Arg2.

‘68010 Registers’

VBR=xxxxxxxx SFC=xxxxxxxx DFC=xxxxxxxx

‘68020 Registers’

VBR=xxxxxxxx SFC=xxxxxxxx DFC=xxxxxxxx

MSP=xxxxxxxx ISP=xxxxxxxx CACR=xxxxxxxx CAAR=xxxxxxxx

‘68030 Registers’

VBR=xxxxxxxx SFC=xxxxxxxx DFC=xxxxxxxx

MSP=xxxxxxxx ISP=xxxxxxxx CACR=xxxxxxxx CAAR=xxxxxxxx

CRP=xxxxxxxxxxxxxxxx SRP=xxxxxxxxxxxxxxxx

TT0=xxxxxxxx TT1=xxxxxxxx TC=xxxx PSR=xxxxxxxx

‘68040 Registers’

VBR=xxxxxxxx SFC=xxxxxxxx DFC=xxxxxxxx

MSP=xxxxxxxx ISP=xxxxxxxx CACR=xxxxxxxx

URP=xxxxxxxx SRP=xxxxxxxx TC=xxxx PSR=xxxxxxxx

ITT0=xxxxxxxx ITT1=xxxxxxxx DTT0=xxxxxxxx DTT1=xxxxxxxx

‘68060 Registers’

VBR=xxxxxxxx SFC=xxxxxxxx DFC=xxxxxxxx

CACR=xxxxxxxx PCR=xxxxxxxx BUSCR=xxxxxxxx

URP=xxxxxxxx SRP=xxxxxxxx TC=xxxx PSR=xxxxxxxx

ITT0=xxxxxxxx ITT1=xxxxxxxx DTT0=xxxxxxxx DTT1=xxxxxxxx

Type Information

xxxxxxxx [Symbol] Mnemonic operand1[,…]]

(EA): [Address1=Contents]…[Address2=Contents]

In the ‘(EA)’ line you can see the addresses and their contents the current command accesses. The contents of illegal addresses aren’t shown.

5.1.2 Local Menus

• Close Window

  closes the ‘REGWindow’, all connected windows and disactivates the Debugger for this task. To disactivate the Debugger you have to choose if the task should keep running so it’s the task’s business to stop. Furthermore you can end the task by runing the cleanup routine of the task or just removing the task from the list but this can cause sideeffects you can’t always oversee. If the task is a process then the Remove option is equal to the Cleanup option. If it’s only a task the Cleanup option is equal to the Cleanup option. Beware that the Remove option doesn’t free any resources of the task.

  You should really know what you’re doing if you for example remove a task from the system.

• ZOOM Windows

  expands all windows of the task.

• Log File

  activates or disactivates the loging of the register and PC changes.

• Big View

  shrinks the ‘REGWindow’ to a 68000 register layout or expands it back to the full layout.

• Open DissWindow

  opens a DissWindow with the configured dimensions.

• Open MemWindow

  opens a MemWindow with the configured dimensions.

• Open FPUWindow

  opens a FPUWindow with the configured dimensions. The menu is only available if a FPU is installed.

• Open BreakWindow

  opens a BreakpointWindow with the configured dimensions.

• Open CoppWindow

  opens a CoppWindow with the configured dimensions.

• Open StructWindow

  opens a StructWindow with the configured dimensions.

• Open SnoopWindow

  opens a SnoopWindow with the configured dimensions.

• Open WatchWindow

  opens a WatchpointWindow with the configured dimensions.

• Open ChecksumWindow

  opens a ChecksumWindow with the configured dimensions.

• Save Window Settings

  saves the positions and count of all window the current task controlls. The saved file then contains the appropriate commands you have to enter yourself into the configuration file. Because of the Debugger’s window concept it makes no sense to save a full configurations file.

5.1.3 Public Menus

• Step 1

  runs the current command and stops the task afterwords.

• Step X

  runs X commands and stops the task afterwards.

• Step Debug Line

  runs commands until the PC meets another source line. If the PC is outside the program or if no debug informations are available a single step i used. The command enters rubroutines.

• Trace Debug Line

  is simular to ‘Step Debug Line’ with the exception that it runs subroutines.

• Trace over Calls

  runs the current command or subroutine and stops the task afterwards. Depending on the configuration and the memory area a breakpoint or single steps are used. If a crashes happen in certain program parts you should remove the command ‘Tracebreak’ from the configuration.

  You should avoid to use ‘Tracebreak’ in Libraries and Devices that are located in the ram. If another task accesses the routine at the same time you can expect an illegal exception.

  Some Amiga MMU Setups don’t like that programs write to the kickstart rom. For example breakpoints.

• Trace X over Calls

  runs X commands or subroutines and stops the task afterwards. Depending on the configuration and the memory area a breakpoint or single steps are used.

• Trace Work

  is simular to the command ‘Trace over Calls’ with the exception that all commands are run. This function is useful to trace loops.

  Example:
             moveq        #10,d0
         0$:
             dbra         d0,0$
  
  

  If you use the function on the command ‘dbra’ the Debugger sets a breakpoint after the dbra and runs the task. It drops back to single step when it hits a ‘Jmp’, ‘bra’, ‘rts’….

• Trace over OS-Calls

  runs the current command or the OS function and stops the task afterwards.

• Trace on Flow

  stops the task when a PC direction occurs. This means the PC is stopped when it hits a ‘Jsr’, ‘Jmp’, ‘bcc’, ‘rts’….

• Trace on Adress

  runs the task until the PC is equal to the entered address. This function is not very fast because the task is running in single step mode and after each instruction the PC is compared with the Adress.

• Trace out of OS

  runs the task until the PC is outside of the kickstart. This functions is useful when you catch a task inside the OS and you wanna get as fast as possible back to the program’s code. It works simular as ‘Trace on Adress’.

  You shouldn’t use this command if your task only runs in the kickstart.

• (PC)++

  jumps over the current command. Useful to jump over ‘Illegal’ breakpoints that you can use for debugging purposes in your program.

• PC-2

  subtract 2 Bytes from the PC.

• Write Nop

  overwrites the current command with a ‘Nop’.

• Write Illegal

  overwrites the current command with an ‘Illegal’.

• Run Task

  runs the task and only stops on exceptions.

• Run Watched Task

  runs the task in trace mode and stops when a WatchPoint condition is true. If there are no watchpoints the command behaves like ‘Run Task’.

• Run History Task

  runs the task in trace mode and saves the registers each step into the history stack.

• Stop Task

  stops the task.

• Send Signal

  sends a signal to the task. Default Signal is CTRL-C = 12

• Undo Level

  sets the undobuffer’s depth.

• Undo

  undos the last changes in the registerframe.

• View Refresh

  activates and disactivates the copperlist refresh after each trace operation. This function is helpful if you debug programs that install own copperlists.

• Show (EA)

  activates and disactivates the output of the address and address contents that are access by the current assembler command.

• Symbol

  activates and disactivates the use of symbols in the ‘REGWindow’.

• Delete Symbols

  erases all symbols of the task.

• Copy Symbols

  can copy a symbol list of the task to a different task. This function is helpful if you a task is started from another task and you wanna keep the symbol list.

• Load Symbols

  loads the symbols of a program where you can select an alternative process’s segmentlist for calculating the symbol and debug informations. Normally you choose the same process but sometimes it’s helpful to select a different process. For example if the task you debug is created in a program you have to choose the program’s task to get the correct symbol addresses.

• Set Hunklist

  sets a new segment list for the SourceWindow and some other hunk related functions. Because the position in the SourceWindow depends on the segments it’s sometimes helpful if you load new symbols and debug informations for this task. If you load an alternative Hunklist by selecting a custom task when you use ‘Load Symbols’ this routine is called automaticly.

• Reset Hunklist

  removes the alternative hunklist.

• Show Value

  shows the value of an argument.

• Show Last Exception

  shows the last exception.

• Open Task Window

  opens a window to show the task structure of the task.

• Open System Window

  opens a window to show the ExecBase structure.

• Open Proces Window

  opens a window to show the process structure of the process.

• Open CLI Window

  opens a window to show the cli structure of the process.

• Open Hunk Window

  opens a window to show the hunks of the process.

• Open Symbol Window

  opens a window to show the symbols of the process. If you doubleclick on a symbol you get the hunk where the symbol is located.

• Open Library Window

  opens a window to show the libraries. If you doubleclick on a library entry it opens a ‘FD:’ window that shows all functions of the library when the library is defined in the ‘Barfly.FD’ file. Furthermore if you doublelick on a function you have the choice to see the function in a ‘DissWindow’ or the autodocs documentation.

• Open Device Window

  opens a window to show the devices.

• Open Resource Window

  opens a window to show the resources.

• Open Port Window

  opens a window to show the public ports.

• Open Resident Window

  opens a window to show the resident modules.

• Open Interrupt Window

  opens a window to show the interrupts.

• Open AutoDocs Window

  opens a filerequester to choose the needed autodocs information of a library. Now a window is opened that shows all function of the chosen autodoc file. If you now click on a function another window is opened that shows the function documentation.

• Open History Window

  opens a HistoryWindow that shows the last saved registerframes of the undobuffer. The undobuffer is organized as a stack that the first entry is the last entry in the HistoryWindow. The HistoryWindow isn’t updated automatic.

• Stack Check

  controlls the stack check. If the register A7 points out of the stack bounds or points on an odd address a warning is shown. The Debugger only checks the task when the task give back the control to the traproutine, so it’s not possible to notice every stack problem.

  You should be aware that this function doesn’t work with a WShell task because the ‘WShell’ doesn’t set the correct stack task values.

• Find Task of Adress

  trys to find the task that belongs to the entered address. The command checks if the address is in the task,process,cli, mementry structure and the hunks. It’s not safe to assume that the function can check all cases.

• Load Binary

  loads a file with an optional length into a memory area. If the Debugger should allocate the memory block automaticly you have to close the memory requester.

• Save Binary

  saves a memory area into a file.

• Freeze Task

  freezes a selectable task. When bdebug ends the frozen tasks are warmed up again.

• Warm up Task

  warms up a frozen task.

• Kill Task

  kills a selectable task.

  You should know what task you can kill.

• Show Task

  shows the task structure of a selectable task.

• Show Prozess

  shows the process structure of a selectable process.

• Show CLI

  shows the cli structure of a selectable process.

• Show Hunk

  shows the hunks of a selectable process.

• Send Task Signal

  sends a signal to a selectable task.

• Set Task Priority

  sets a priority of a selectable task.

• Refresh Code Cache

  refreshes the Code Cache.

• Refresh Data Cache

  refreshes the Data Cache

6 Usage of BDebug

6.1 The FPU Window

6.1.1 FPU Window

The FPU Window shows the FPU register FP0 to FP7 in the 96Bit Extended format and the registers FPCR,FPSR and FPIAR in hexadecimal. You can only open this window if a FPU is available.

Register Window Layout

FP0=FloatingPoint

FP1=FloatingPoint

FP2=FloatingPoint

FP3=FloatingPoint

FP4=FloatingPoint

FP5=FloatingPoint

FP6=FloatingPoint

FP7=FloatingPoint

FPCR=xxxxxxxx FPSR=xxxxxxxx

FPIAR=xxxxxxxx

6.1.2 Local Menus

• Close Window

  closes the window.

7 Usage of BDebug

7.1 The Disassembler Window

7.1.1 Disassembler window

The ‘DissWindow’ shows the memory contents in assembler mnemonics. The address of the window’s view can be absolut or relative. In the absolut mode the window is set to a fixed adress and you can read in the title ‘No Link’. In the relative mode the window is connected with a register so the window’s view depends on the registers value. You can see this mode by the title string ‘Link to *’ where * represents the register name. The PC is shown by the colour pen 2. If the linked register value is outside of the window’s view area the whole contents of the window will be refreshed. You can change size of the window and scroll through the memory area by using the cursors. In the title you see an ID-String with the format ‘\#x.y’ where ‘X’ represents the ‘REGWindow’ number and ‘y’ the number of the ‘MemWindow’. By a doubleclick in a line of the window you can sets or remove a breakpoint. You can disable this function in the configuration.

7.1.2 Local Menus

• Close Window

  closes the window.

• Shrink Window

  shrinks the window.

• Expand Window

  expands the window to screen size.

• Link to Register

  links the window with a register. If you enter the string ‘NO’ it switches to the absolute mode.

• Change Adress

  changes the view address of the window.

• Clear Adress

  resets the view address of the window.

• Refresh Window

  refreshes the window.

• .W Branches

  activates and disactivates the output of the old branch width size.

• Neg. Offsets

  activates and disactivates the output of negative values in the indirect address modes with offset.

• Neg. Data

  activates and disactivates the output of negative values in the direkt address mode.

• Opcode Data

  activates and disactivates the additional output of the command bytes.

• Auto Refresh

  activates and disactivates the global refresh of the window after each step.

• Symbols

  activates and disactivates the symbol output in the window.

• Show Lib Call

  activates and disactivates the symbolic output of library functions so all library functions that are defined in the configuration file ‘<BarflyPath>/Barfly/BARFLY.FD’ are recognized.

• Guess Lib Call

  activates and disactivates the guessing of function call names. It only works in connection with the option ‘Show Lib Call’. Fortunately you can’t expect that the function names always fit because the the library base register A6 can change until the program counter meets the function.

• Mark Block End

  activates and disactivates marking after the instruction ‘JMP’,‘BRA’,‘RTS’,‘RTE’,‘RTD’ and ‘RTR’ to make program blocks more visible.

• Set/Clear Breakpoint

  sets/removes a breakpoint on the first entry in the window. Breakpoints are shown by changing the pen from colour 1 to colour 3 and the char ‘>’ at the beginning of a line.

• Pick/Clear Breakpoint

  sets/removes a breakpoint through a symbol list.

• Disassemble to File

  disassembles a memory area into a file.

8 Usage of BDebug

8.1 The Memory Window

8.1.1 Memory window

The ‘MemWindow’ shows the memory contents hexadecimal and in ascii.You can change size of the window and scroll through the memory area by using the cursors. In the title you see an ID-String with the format ‘\#x.y’ where ‘X’ represents the ‘REGWindow’ number and ‘y’ the number of the ‘MemWindow’.

8.1.2 Local Menus

• Close Window

  closes the window.

• Shrink Window

  shrinks the window.

• Expand Window

  expands the window to screen size.

• Link to Register

  links the window with a register. If you enter the string ‘NO’ it switches to the absolute mode.

• Change Adress

  changes the view address of the window.

• Clear Adress

  resets the view address of the window.

• Refresh Window

  refreshes the window.

• Memory Offset Step

  defines the data format in the window. The following options can be selected: ‘None’, ‘Byte’, ‘Word’ and ‘Long’.

• Edit

  activates the edit mode of the ‘MemWindow’. In the edit mode you can switch between hex and ascii input by the key ‘RETURN’. With ‘ESC’ you can leave the edit mode. Only the cursor right and left are changed to the normal. With these both keys you can access each Byte. In the edit mode you can’t change the size of the window.

• Copy

  copies a memory area into another memory area. The function uses ‘CopyMem’ so it doesn’t handle memory areas that overlap.

• Fill

  fills a memory area with a value of a certain data-width.

• Compare

  compares a memory area with another memory area.

• Search

  searches a value of a certain data-width in a memory area. If the value is found the address and the value are shown and you can goon with ‘Search Next’ to find the next address.

• Search Next

  Searches the next value. Look at ‘Search’

• Pred

  sets the address of the window on the preceding entry of the list. If the node points on an odd, illegal or address NULL the command has no effect. The next node is equal to ‘LN_PRED’, the second longword of the memory view.

• Succ

  sets the address of the window on the next entry of the list. If the node points on an odd, illegal or address NULL the command has no effect. The next node is equal to ‘LN_SUCC’, the first longword of the memory view.

9 Usage of BDebug

9.1 The Copper Window

9.1.1 CopperWindow

The ‘CopperWindow’ shows the memory contents as copper commands. You can change size of the window and scroll through the memory area by using the cursors. In the title you see an ID-String with the format ‘\#x.y’ where ‘X’ represents the ‘REGWindow’ number and ‘y’ the number of the ‘CoppWindow’.

9.1.2 Local Menus

• Close Window

  closes the window.

• Shrink Window

  shrinks the window.

• Expand Window

  expands the window to screen size.

• Link to Register

  links the window with a register. If you enter the string ‘NO’ it switches to the absolute mode.

• Change Adress

  changes the view address of the window.

• Clear Adress

  resets the view address of the window.

• Refresh Window

  refreshes the window.

• Goto Into List

  sets the window list on the standard copperlist ‘GfxBase->gb_copinit’.

10 Usage of BDebug

10.1 The Structure Window

10.1.1 StructWindow

opens window that can be connected with a structure. You can use new structure entries by expanding the the ‘<BarflyPath>/Barfly/Barfly.Include’ file or loading a new custom file. By a doubleclick on a structure window entry you can cause several actions depending on the datatype. Every datatype is connected with an action that is normally started automaticly. With the configuration command ‘NoAutoStructAction’ you can change this behaviour so that an action type requester is opened.

The following datatypes are available.

• APTR opens a MemWindow.
• CSTR shows a string.
• BPTR opens a MemWindow at the address BPTR*4.
• BSTR shows a string at the address (BPTR*4)+1
• CPTR opens a DissWindow.
• FPTR opens a DissWindow.
• BYTE doesn’t cause an action.
• WORD doesn’t cause an action.
• LONG doesn’t cause an action.
• FLOAT doesn’t cause an action.
• DOUBLE doesn’t cause an action.
• EXTENDED doesn’t cause an action.
• RPTR doesn’t cause an action.

The following action types are available.

• MemWindow opens a MemWindow.
• DissWindow opens a DissWindow.
• CoppWindow opens a CoppWindow.
• StructWindow opens a StructWindow.
• NewStruct sets a new structure.

10.1.2 Structure Macro Fileformat

In the beginning you define the root directory entries with the Macro ‘Menudir’. The first parameter is the name of the entry,then the address of the parent directory and then the address of the subdirectory. In the root directory the parent address is fortunately NULL. The last entry of the directory is defined by the Macro ‘MENUDIREND’.

‘Label                   ListViewMacro           Link’
RootDir:
                        .
                        .
                        MENUDIR                 exec,0,Exec_Dir
                        .
                        .
MYCUSTOMENTRY:							
                        MENUDIREND              CUSTOM,0,0	

The design of a subdirectory only differs from the root directory entries by a parent directory address.

‘Label                   ListViewMacro           Link’
Exec_Dir:
                        .
                        .
                        MENUDIR                 nodes.i,RootDir,Nodes_Dir
                        .
                        .
                        MENUDIREND              tasks.i,RootDir,Tasks_Dir

to define the structure directory entries you have to use ‘MENUITEM’ and ‘MENUITEMEND’. The first parameter in the Item Macros is the name of the entry and also the name of the structure. The second parameter defines the address of the parent directory.

‘Label                   ListViewMacro           Link’
                        .
                        .
Nodes_Dir:
                        MENUITEM                LN,Exec_Dir	
                        .
                        .
                        MENUITEMEND

To define a structure you can use the normal assembler syntax that you probably have to adjust to your custom needs. For example you can tell BDebug more informations about the datatype an entry represents. By redefining ‘APTR’ to a ‘CSTR’ you can tell Debugger that the entry is a stringpointer. Or you can tell that ‘APTR’ points to a structure by ‘APTR LN_SUCC,Node’.

‘Label                   IncludeTypeMacro        Name,Link’
LN_Struct:
                        STRUCTUREB              LN,0
                        APTR                    LN_SUCC,LN
                        APTR                    LN_PRED,LN
                        UBYTE                   LN_TYPE
                        BYTE                    LN_PRI
                        CCSTR                   LN_NAME
                        LABEL                   LN_SIZE

10.1.3 Local Menus

• Close Window

  closes the window.

• Shrink Window

  shrinks the window.

• Expand Window

  expands the window to screen size.

• Link to Register

  links the window with a register. If you enter the string ‘NO’ it switches to the absolute mode.

• Change Adress

  changes the view address of the window.

• Clear Adress

  resets the view address of the window.

• Refresh Window

  refreshes the window.

• Load Custom Struct

  loads additional structure files. The new structure entries are place in the ‘CUSTOM’ directory. The format of custom structure files is equal to the file ‘BARFLY.INCLUDE’.

• Select Structure

  opens the structure include directory requester where you can select the needed structure. The parent gadget is placed in the upper border.

• Goto Sysbase…

  sets the window adress on the ExecBase.

• Goto Gfxbase…

  sets the window address on the GFXBase.

• Save Window….

  saves the contents of the window in a file.

• Full Address

  this switch decides if the ‘StructWindow’ also shows the address of the entries.

• Offset Address

  this switch decides if the ‘StructWindow’ also shows the offset of the entries.

• Pred

  sets the address of the window on the preceding entry of the list. If the node points on an odd, illegal or address NULL the command has no effect. The next node is equal to ‘LN_PRED’, the second longword of the memory view.

• Succ

  sets the address of the window on the next entry of the list. If the node points on an odd, illegal or address NULL the command has no effect. The next node is equal to ‘LN_SUCC’, the first longword of the memory view.

11 Usage of BDebug

11.1 The Structure Window

11.1.1 Source window

The ‘SourceWindow’ shows the source line that belongs to the window address. If the program file doesn’t have the needed debug informations the ‘Source window’ can’t be opened. If the address points to an area with no relevant debug information, for example the Kickstart or beyond the program hunks, you only see a small message.

11.1.2 Local Menus

• Close Window

  closes the window.

• Shrink Window

  shrinks the window.

• Expand Window

  expands the window to screen size.

• Link to Register

  links the window with a register. If you enter the string ‘NO’ it switches to the absolute mode.

• Change Adress

  changes the view address of the window.

• Clear Adress

  resets the view address of the window.

• Refresh Window

  refreshes the window.

• Set Breakpoint

  sets a breakpoint on the active line.

• Show HunkInfo

  shows the hunk of the current source line.

12 Usage of BDebug

12.1 The Snoop Window

12.1.1 Snoop Window

The ‘SnoopWindow’ snoops the task’s allocations.

12.1.2 Local Menus

• Close Window

  closes the window.

• Shrink Window

  shrinks the window.

• Expand Window

  expands the window to screen size.

• Refresh Window

  refreshes the window.

• Auto Refresh

  activates/disactivates display refresh by an allocation.

• Snoop Memory

  activates/disactivates snooping.

• Snoop Mask

  sets the allocation filter mask. Is the Mask 20 only allocations with the size 20 are recorded. Default -1.

• Snoop Max Entries

  sets the maximal recorded snoop entries.

13 Usage of BDebug

13.1 The Breakpoint Window

13.1.1 Breakpoint window

The ‘BreakWindow’ handles all breakpoints and contains the functions that are needed with breakpoints. In general breakpoints are addresses in the program where the task should be stopped. The breakpoints are handled global so they aren’t deleted when close the window.

13.1.2 Local Menus

• Toggle

  activates and disactivates all breakpoints.

• All

  selects all breakpoints.

• Clear

  unselects all breakpoints.

• On

  activates all selected breakpoints.

• Off

  disactivates all selected breakpoints.

• Hit

  sets the amount of hits for a breakpoint until it should stop the program. Default is 1.

• ?

  shows the hunk where the breakpoint is located and if the breakpoint is equal to a symbol.

• Input

  this breakpoint sets and removes a breakpoint.

• Pick

  this breakpoint sets and removes a breakpoint using the symbol list.

• Delete

  removes every selected breakpoint.

• Goto

  opens a DissWindow for every selected breakpoint.

• Run

  runs the program until the PC hits a selected breakpoint.

14 Usage of BDebug

14.1 The Watchpoint Window

14.1.1 Watchpoint window

The ‘Watchwindow’ allows to set breakpoints that aren’t dependend on a certain PC address but from other conditions. Every watchpoint has a condition,data width and state if it’s activated or not. There are 3 types of different watchpoints available now. The ‘Memory’ watchpoint compares the saved contents of the address with the current contents and dependent on the condition the program is stopped or not. The ‘Register’ watchpoint compares the saved contents of a register with the current contents and dependent on the condition the program is stopped or not. The ‘Argument’ watchpoint compares the saved value of an argument with the current contents and dependent on the condition the program is stopped or not. The last watchpoint type is the most powerful because it can simulate the first two types with the cost of a slowdown. The use of watchpoints is very time consuming because the whole program is run in single stepping To use watchpoints you have to run the task with ‘Run Watched Task’.

If an error happens during a dynamic argument in the exception handler the screen is blinked.

14.1.2 Local Menus

• Toggle

  activates and disactivates all watchpoints.

• All

  selects all watchpoints.

• Clear

  unselects all watchpoints.

• On

  activates all selected watchpoints.

• Off

  disactivates all selected watchpoints.

• Add

  opens a requester where the parameter for a watchpoint have to be adjusted and adds the new watchpoint to the list. If you doubeclick on a watchpoint you can change the parameter.

• Refresh

  refreshes the watchpoint arguments.

• Check

  checks all selected watchpoints.

• Delete

  removes all selected watchpoints.

15 Usage of BDebug

15.1 The Checksum Window

15.1.1 Checksum Window

The ‘ChecksumWindow’ controlls all checksum areas that are been checked each time the task stops. Helpful to find illegal random writes bugs. The checkpoints are controlled global so they aren’t deleted when you close the window.

15.1.2 Local Menus

• Toggle

  activates or disactivates all checksum areas.

• All

  selects all checksum areas.

• Clear

  unselects all checksum areas.

• On

  activates all selected checksum areas.

• Off

  disactivates all selected checksum areas.

• Address

  adds a checksum area into the list.

• Hunk

  adds a hunk of the current process into the checksum area list.

• Task

  adds a hunk of selectable process into the checksum area list.

• Refresh

  calculate a new checksum for all selected areas.

• Delete

  removes all selected checksum areas.

• Check

  checks all areas for checksum errors.

16 Usage of BDebug

16.1 Requester Arguments

16.1.1 Argument Structur

An argument can use absolut values,symbols and registers as operands and the operators +,-,*,/,|,!,&,<<,>>,~. Additionally to the normal symbols there are some special symbols available.

• By {Argument}.[b,w,l] you can read from a memory address, that is defined by the argument. If you specify an illegal address that isn’t defined in the legal memory space an error is shown.
• \#d? represents the address of the ‘Disswindows’ with the ID ?
• \#m? represents the address of the ‘Memwindows’ with the ID ?
• \#c? represents the address of the ‘Coppwindows’ with the ID ?
• \#h? represents the address of the hunk ?. Helpful for enforcer Hunk:Offset output
• \#ea? represents the address of the EA with the number ?. Check Register Window.
• \#em? represents the contents where the address EA number ? points to. Check Register Window. If the address EA is illegal an error is shown.
• \#ls represents the start address of a loaded binary file.
• \#le represents the end address of a loaded binary file.
• \#ll represents the length address of a loaded binary file.
• \#p represents the start address of the programs. Only true for a loaded program.

If you have the following Enforcer Hit output ‘Hunk 0:$11c’ you can calculate the adress by entering the argument #h0+$11c.

17 Usage of BDebug

17.1 Technical Informations

17.1.1 Exceptions

The Debugger can catch all exceptions if the system is still working. If an exception is caused the traphandler catches the exception and tells the Debugger what went on so it can react on the exception. If the exception wasn’t caused by the Debugger the type and the possible reason for the exception is shown. The ‘Return-Adress’ of the debugged task points on an internal ‘ILLEGAL’. If the PC points on this ‘ILLEGAL’ the task is closed and all windows are removed. You should step over this ‘ILLEGAL’ because it increases possibility of a system crash. If a task is caught by ‘Debug Next Task’ and notices a ‘finalPC’ pointer the ‘Return-Adress’ isn’t set on an internal ‘ILLEGAL’ because the ‘finalPC’ pointer is sometimes used for parsing an argument. In this case the Debugger notices that the task ends by the RemTask() function.

If the task changes the ‘Return-Adress’ the Debugger tries to determine the taskend by ‘RemTask’.

17.1.2 Exception Handler

Every task contains in the task structure a pointer to its exception handler that is named ‘TC_TRAPCODE’ When an exception happens in this task the exception checks if the Debugger knows this task. If this is not the case something seriously is broken and the Deadend Alert 35000000 will be poped up. If all goes well the registers are saved, the Debugger task gets a message and the exception handler waits for a msg by the Debugger to go on. When the Debugger gets the message it causes the appropriate function. For example refreshing the windows. If the Debugger gets a step command it sends the exception handler the appropriate message and the handler does a step.

17.1.3 Debug Informations

Currently the following formats are supported.

• BASM Specialformat This format allows the Debugger to decide if the code is in the Mainpart,Includes or in a Macro.
• SAS D1 This format only allows a Source-Code connection. It doesn’t support local variables,Structures and Macros.
• GCC STABS This format is very powerful and offers all a source-level Debugger needs. Unfortunately the Debugger only supports a simple Source-Code connection at the moment. It’s planned to support more in the future.

17.1.4 GCC Compiler and BDebug

Unfortunately you can’t debug programs that are using the current ‘ixemul.library’ because in Openlibrary() initroutine the Task field TC_TRAPCODE is changed. Hopefully there’ll be soon an ‘ixemul.library’ available that doesn’t change the traphandler. If you’re using GCC with the link lib ‘gerlib’ that is available on Aminet FTP Servers you shouldn’t experience any problems with BDebug.

18 Usage of BDebug

18.1 Configuration

The default configuration file is named ‘BDEBUG.Config’ and is located in the directory ‘<BarflyPath>/’ or ‘s:Barfly/’. Obviously it’s not optimal to be forced to use the same config file for different programs. Therefore you can also specify a local config file with program name and the suffix ‘.BDebug’.

18.1.1 ToolTypes

The following tooltypes are supported to activate the know functions of the commandwindow.

• CatchNextTask
• CatchCrashedTask
• CatchEnforcerHit

18.1.2 Barfly.FD

If you want to create a new ‘Barfly.FD’ file that contains the library function name you have to follow the following the instructions. First the assign ‘FD:’ has to point to the directory that contains the FD files that should be contained in the new ‘Barfly.FD’. Afterwards you should check every FD file if the Library, Resource, Device name exist in the first line in the following style: ‘* "foobar.libary"’. If this is not the case you have to add the name yourself so that a correct FD database can be build up. If you’re more experienced with FD files you can yourself add new entries to the ‘Barfly.FD’ file because the layout is pretty obvious.

18.1.3 Configuration Commands

Window Config Commands…

Misc Commands…

18.1.4 Register window

18.1.4.1 RegWindow=x/y/width/height/register

This command defines the position of a ‘REGWindow’.

18.1.4.2 RegFlags=flag[|flags…]

This command defines certain flags in the ‘REGWindows’.

• AUTOVIEWREFRESH
• SYMBOLS
• STACKCHECK
• NOBIGVIEW

18.1.5 FPU Window

18.1.5.1 FpuWindow=x/y/width/height/register

This command defines the position of a ‘FPUWindow’.

18.1.5.2 OpenFPUWindows=Count

This command tells the Debugger to open a ‘FPUWindow’.

18.1.6 Disassembler window

18.1.6.1 DissWindow=x/y/width/height/register

This command defines the position,the dimension and linked register of the ‘DissWindow’.

Beispiel: DISSWINDOW=0/0/300/100/PC

18.1.6.2 DissFlags=flag[|flags…]

This command defines certain flags in the ‘DISSWindow’.

• AUTOREFRESH
• SHOWLIB
• GUESSLIB
• SHOWEA
• WORDBRANCHES
• NEGOFFSETS
• NEGDI
• OPCODEDATA
• BLANKAFTERJMPBRA

18.1.6.3 OpenDissWindows=Count

This command tells the Debugger to open a number of ‘DissWindows’.

18.1.7 Memory window

18.1.7.1 MemWindow=x/y/width/height/register

This command defines the position,the dimension and linked register of the ‘MemWindow’.

Example: MEMWINDOW=0/0/300/100/A0

18.1.7.2 OpenMemWindows=Count

This command tells the Debugger to open a number of ‘MemWindows’.

18.1.7.3 MemoryOffsetStep=Count

This command defines the Offset-Step of the ‘MemWindows’.

• 0 no Space
• 1 Space after each Byte.
• 2 Space after each Word.
• 4 Space after each Longword.

18.1.8 Copper window

18.1.8.1 CoppWindow=x/y/width/height/register

This command defines the position,the dimension and linked register of the ‘CoppWindow’.

Example: COPPWINDOW=0/0/300/100/A0

18.1.8.2 OpenCoppWindows=Count

This command tells the Debugger to open a number of ‘CoppWindows’.

18.1.9 StructWindow

18.1.9.1 StructWindow=x/y/width/height/register

This command defines the position,the dimension and linked register of the ‘StructWindow’.

Example: StructWINDOW=0/0/300/100/A0

18.1.9.2 StructFlags=flag[|flags…]

This command defines certain flags for the ‘StructWindow’

• AUTOREFRESH
• ADDRESSFORMAT
• OFFSETFORMAT
• NEWWINDOW

18.1.9.3 OpenStructWindows=Count

This command tells the Debugger to open a number of ‘StructWindows’.

18.1.10 Source window

18.1.10.1 SourceWindow=x/y/width/height/register

This command defines the position,the dimension and linked register of the ‘SourceWindow’.

Example: SOURCEWINDOW=0/0/300/100/A0

18.1.10.2 OpenSourceWindows=Count

This command tells the Debugger to open a number of ‘SourceWindows’.

18.1.11 Breakpoint window

18.1.11.1 BreakWindow=x/y/width/height

This command defines the position of a ‘BreakPointWindow’.

18.1.11.2 OpenBreakWindows=Count

This command tells the Debugger to open a ‘BreakPointWindow’.

18.1.12 Watchpoint window

18.1.12.1 WatchWindow=x/y/width/height

This command defines the position of a ‘WatchpoinzWindow’.

18.1.12.2 OpenWatchWindows=Count

This command tells the Debugger to open a ‘WatchPointWindow’.

18.1.13 Checksum window

18.1.13.1 ChecksumWindow=x/y/width/height

This command defines the position of a ‘ChecksumWindow’.

18.1.13.2 ChecksumWindows=Count

This command tells the Debugger to open a ‘ChecksumWindow’.

18.1.14 SnoopMemory window

18.1.14.1 SnoopMemWindow=x/y/width/height/register

This command defines the position of a ‘SnoopMemWindow’.

18.1.14.2 OpenSnoopMemWindow=Count

This command tells the Debugger to open a ‘SnoopMemWindow’.

18.1.14.3 SnoopMask=Mask

This command defines the snoop mask. The mask defines the length of memory blocks that should be recorded. Default is -1 so everything is recorded.

18.1.14.4 SnoopMax=Count

This command defines the count of snoop entries. Default is 100.

18.1.14.5 HistoryEntrys=Count

This command defines the count of history entries. Default is 5.

18.1.15 Information Windows

18.1.15.1 GlobalViewWindow=x/y/width/height

This command defines the position and dimensions of a standard information window. For example the Library Window belongs to this group.

Example: GLOBALVIEWWINDOW=0/0/300/100 GLOBALVIEWWINDOW=0/200/300/100

18.1.16 Other Windows

18.1.16.1 CommandWindow=x/y/width/height

This command defines the position of the small ‘CommandWindow’. This command has no function in local configuration files.

18.1.16.2 FileShell=<Window Specifikation>

This command defines the shell that is opened with the loaded program. You should always open the shell on the Debugger’s Public Screen. The shell parameters are the same you know from the CLI.

18.1.17 Misc

18.1.17.1 TaskStack=Count

This command defines the stack of the loaded program. Defaullt are 4096 Bytes.

18.1.17.2 Priority=Count

This command defines the Debugger’s priority.

18.1.17.3 SetBreak=Argument

This command can be used to define a list of breakpoints that are set before the program is started. This is useful to pass the module ‘Main.c’ for example. If no breakpoints are defined or if a parsing problem occurs the standard breakpoint,first program instruction, is set.

• SETBREAK=_main ; SAS C Main Program Start
• SETBREAK=_main ; GCC C Main Program Start
• SETBREAK=@main ; DICE C Main Program Start
• SETBREAK=! ; Programstart(Default)

18.1.17.4 ClickBreak=State

This command can be used to define the action of the DissWindow on a doubleclick.

‘State=0’

No Action(Default).

‘State=1’

Set/Clear Breakpoint and pop up a Requester for a Set.

‘State=2’

Set/Clear Breakpoint.

18.1.17.5 ShowMem=Start:End

defines the adress areas that are legal to the Debugger so you can look at adress areas that are not in the memorylist or in the rom. Illegal adress areas are shown with ‘*’ in the windows. You should ‘never’ define the custom chip areas as legal because a read access on a writeonly register can cause a deadly crash.

Example: SHOWMEM=$e80000:$f00000 defines the Zorro 2 area as free.

By this command you can overrule the internal enforcer legal memory areas so you should beware of hits.

18.1.17.6 DefCommand=Key,Qualifier[|Qualifier…],Function

This commands allows to connect menu functions with key sequences. Because of the object-oriented concept of the Debugger that allowes multiple instances of objects it’s not easy to decide what object is meant. Therefore if the object is active it’s used and if no object of this type is active the first entry the object-type list is used. As the key parameter every Rawkey can be used with the exception of ‘TAB’ and the functionkeys that are used internal. The key is searched first in the local and then in the global configuration.

As qualifiers you can use the following keys.

• LSHIFT
• RSHIFT
• CAPSLOCK
• CTRL
• LALT
• RALT
• LCOMMAND
• RCOMMAND

Bespiel: DEFCOMMAND=$15,CTRL,"Step 1 Position"

Defines CTRL-Z as Step 1 Position

18.1.17.7 AutoDocDir=<Path>

This command sets the path for the autodocs directory.

18.1.17.8 AutoDocAlias=Library,File

This command sets an alias for Libraries,Devices or Resources to define the connected Autodocs file. There’s no other way because it’s not possible to build the autodocs file by knowing the library name.

18.1.17.9 ArexxPath=<rx-path>

This command sets the Arexx-Script Start-Command. In a normal system the path should be <sys:Rexxc/rx>.

18.1.17.10 ArexxInput=<File>

This command sets the Arexx-Command Input-File. If you don’t specify the file, NIL: is used.

18.1.17.11 ArexxOutput=<File>

This command sets the Arexx-Command Output-File. If you don’t specify the file, NIL: is used.

18.1.17.12 ArexxCommand=[1…10],<Pfad>

This command sets the 10 entries in the Arexx-Menu. You specify the number and the path of the Arexx-Script.

ArexxCommand=1,"Rexx:Example.rexx"

18.1.17.13 ExecuteCommand=<File>

this command can set up a list of programs that should be run before the debugged program’s task is started. This parameter only works with programs that are loaded by the Debugger. Furthermore you have to make sure that the loaded programs have to ‘end’ otherwise the task can’t be started. For example you could use these command to set breakpoints with Arexx-Scripts.

18.1.17.14 LoadInclude

tells the Debugger to load the structure information file ‘Barfly.Include’.

18.1.17.15 AddStructFile=Filename

tells the Debugger to load a custom structure information file and adds it into the CUSTOM/ subtree.

18.1.17.16 ClicktoFront

activates the Debugger’s own ‘ClicktoFront’ handler. This function should only be used if you don’t use an own ‘Commodity’ for this task.

18.1.17.17 CenterWindow

activates the centering mode for every stringrequester windows.

18.1.17.18 ScreenInFront

activates the ‘ScreenToFront’ mode that pops the screen to front after every trace operation.

18.1.17.19 OpenScreen[=width,height,depth,mode]

tells the Debugger to open an own screen. If you don’t enter dimension parameters the wb screen is cloned. You can use the screenmodes in the mode string that you can see in the ‘Prefs/ScreenMode’ requester. This command has no function in local configuration files.

OPENSCREEN=1448,560,2,PAL:HighRes Interlace

18.1.17.20 OpenPubScreen=Name

tells the Debugger to open on the Pubscreen with the specified name. This command has no function in local configuration files.

18.1.17.21 ScreenFont=fontname/Height

defines a font for a Debugger screen. This command has no function in local configuration files.

18.1.17.22 QuietException=Exception Nummer

masks off certain exceptions for the exception requester so that only a ‘DisplayBeep’ is caused instead of a textrequest. With the value -1 you can mask off every exception and for example with the value 4 you mask off the ‘Illegal’ exception.

18.1.17.23 DisableXPointer

disactivate the Wait-Pointer.

18.1.17.24 TraceBreak

tells the Debugger to use breakpoints in the ‘Subroutine’ Traces instead of single steps. The advantage is a speed up and the disadvantage is that you can cause crashes while you step through resident/reentry code.

18.1.17.25 CrashedTask

activates the ‘CatchCrashedTask’ mode.

18.1.17.26 CatchEnforcerHit

activates the ‘CatchEnforcerHit’ mode.

18.1.17.27 DoNotCacheFullFile

tells the Debugger not to cache program files while reading the Symbol/Debug informationen to save memory. Obviously the parsing speed will decrease.

18.1.17.28 DoNotPopPathRequest

tells the Debugger to ignore errors from opening source files and not to open a path requester.

18.1.17.29 NoAutoStructAction

tells the Debugger to open a type-requester by an action in the StructurWindow.

18.1.17.30 NoBreakpointErrors

tells the Debugger to ignore SETBREAK= errors that cause the Debugger to always set an error on the program start.

19 Usage of BDebug

19.1 Arexx

19.1.1 Commands

• RC: -
• result: ’OK’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’,’RESUME’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: -

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’

• RC: -
• result: ’OK’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

• RC: -
• result: ’OK’,’FALSE’

RC : 0=Ok Result: Result-String

RC : 0=Ok Result: Result-String

RC : 0=Ok Result: Result-String

RC : 0=Ok

RC : 0=Ok

RC : 0=Ok

RC : 0=Ok Result: Filepath-String

RC : 0=Ok Result: Filepath-String

• RC: -
• result: ’OK’,’FALSE’

20 Usage of BDebug

20.1 How to use BDebug ?

20.1.1 Problemanalysis

First you should be sure that all necessary configurations file have been installed because without ‘Barfly.FD’ file you don’t see any function names in the disassembler window; and without ‘Barfly.Include’ the ‘StructWindow’ is unusable. Are these preconditions fullfilled you should analyse the problem and anticipate how the Debugger can be used. Because the debugging of programs depends heavily on the situation i can only list some general points. The reality probably looks different… as always:-)

Point of departure:

• Program from the CLI
  • 1 Task

    The program can be started by ‘bdebug Program [Argument]’ or can be loaded the command window ‘Debug File’. By this method all symbol and debug files are loaded. If the Debugger can’t find one source file you can add additional paths if you haven’t disabled this function. The standard breakpoint is the first command in the program. Sometimes this uncomfortable and so you can set a different start breakpoint for example to jump over the CStartup code or to set it on an important program position.

  • Creates further Tasks

    In this case you should be sure how you wanna catch the next Task. You could catch the Task by ‘Next Task’ or compile the program with an ‘illegal’ in the task and catch it with ‘Crashed Task’. After you caught the task you probably would like to use see symbole and debug source. These Informationen can be loaded afterwards by using ‘Load Symbols’.

• Program from the WB

  In this case you should use ‘Next Task’ and then catch the task ‘WBL’. Afterwards you have to activate ‘Next Task’ again and run ‘WBL’. You could also use the ‘illegal’ strategic. After the right task was caught you can load the symbols again.

• Is it a Handler, Filesystem or something simular.

  In this case you should use the ‘illegal’ strategic and catch the task by ‘Crashed Task’. An alternative method would be to catch the waiting task with ‘Debug Task’ and wait as long as the task gets woken up by a signal.

After you’ve solved the first stage how you can controll the problem task you should think about how the problem looks like and where it could be located.

Problem Type:

• Enforcer

  If an Enforcer Hit is caused Enforcer outputs the hit’s program address and mostly also the hunk offset. You can now directly jump to the address by entering the address in the DissWindow by ‘Change Address’ or you open a HunkWindow, doubleclick on the hunk where the hit is located and then enter the offset Enforcer showed. The Debugger itself can also automaticly stop a debugged program if a hit happens.

• Mungwall

  These hits aren’t that easy to find as Enforcer hits because Mungwall hits aren’t showed when the problem happened but only after a ‘FreeMem’. In this case you should remember the memoryblock where it happened and determine where the responsible AllocMem is located in the program, so you get an overview between what area the problem is caused. Now you should open a MemWindow that points to this certain memory area and step through the program and look if something changes the mungwall borders in the MemWindow. Mungwall borders are before and after the allocated memory area. If you’re more experienced you could also use the WatchpointWindow and set a watchpoint on the certain memory block.

• Crash

  If it’s just an ordinary crash the error should be pretty easy to find single stepping through the responsible code area. If it’s a random crash you should be using ‘Crashed Task’ and hope that the task can be caught. After the task got caught you should check the instructions that cause the crash. If the PC points to data fields that don’t look like real code the PC is probably set wrong by a stack cleanup error. In this case you should check the nexts addresses on the stack if these point to legal program code.

• Sideeffects and mysterious

  These bugs are the worst to find and there’s no general strategic how to find them. In these cases only intuition and patience can help.

20.1.2 Problems that can happen

• Why does the Debugger react so slow on keyboard commands that controll the tracing ?

  This happens if you debug a task with a higher priority as the Debugger’s priority. For example. DOS-Handler. Workaround is to higher the priority of the Debugger.

• Why does the Debugger blockate by opening the filerequester.

  This happens when you debug a handler, because the filerequester normally tests every handler with a IsFilesystem(). When you debug a handler it can’t reply the IsFilesystem packet and therefore the filerequester is busy.

• If you debug the following program on a 68040 with 68040.library or 68060.library the instruction ‘rts’ is run if you cause a Single-Step on the instruction ‘fetox’. Because this command isn’t implemented in the 68040 and 68060 it has to be emulated. It seems to forget the tracebit.

  	mc68040
  	fmove.x	#1.3,fp0
  	fmove.x	#255,fp1
  	fetox.x	fp0,fp1
  	rts
  

• If a program doesn’t return from a DOS funktion you could accidently entered a char in shell window.

BAsm 1.0

A cli/arexx controlled Assembler

Copyright (c) 1989-94 Ralph Schmidt

- Shareware -

Using BAsm…

Addendum…

21 The Assembler

The assembler understands the commands and addressmodes from the 68000 through the 68060 and both the Floating-Point Units, 68881 and 68882. It supports only the 68851 MMU commands, which are also supported by the 68030. The assembler achieves it’s speed by translating the source in a single pass, followed by a backpatch phase which corrects all unresolved references.

21.1 Syntax

21.1.1 Comments

A comment can start in several different ways. In a pure comment it starts either with a <;> or <*>. A comment can only be started after an assembler command or symbol with a <;> if an assembler command or symbol exists within that line.

	;A comment
*A comment
	move.l a0,a0	;A comment

21.1.2 Opcode/Instructions arrangement

‘[label[:]] [opcode] [operand[, operand[, operand…]]]]]’

• Opcodes

  An Opcode can be a Motorola Mnemonic, an assembler command, or a Macro call.

• Operations

  In a Motorola mnemonic operands are based on legal addressmoes; in assembler privat instructions the parameters depend on the instruction.

21.1.3 Symbol structure

A symbol can represent the following types:

• Value
• Program Counter
• Register
• Register List
• Macro

Symbols can only be defined once. The exceptions are local labels and symbols defined by <Set>.

Structure rules for Symbols.

• The first letter of a symbol can be one of the following: <a>…<z>, <A>…<Z>,<_>, <@>,<.> and <\>.
• From the second letter on, the symbol can contain the following letters: <a>…<z>,<A>…<Z>,<0>…<9>, <_>,<@> and <.>.
• If a symbol consists of only numbers and ends with <$>, then it is a numerical local label.
• A symbol is ended by an illegal letter.
• If a symbol begins with a <.> or <\>, then it is a local label.
• A macro symbol should not contain a <.>.
• To avoid a conflict, a symbol should not end with <.b>,<.w> or <.l>.

ThisIsALabel              ;That is a normal label
ThisIsALabel1.loop:       ;That is a normal label
This@_Is_@A_@Label
1$:                       ;That is a numerical local label
.ThisIsALabel             ;That is a local label
.ThisIsALael1:            ;That is a local label
\ThisIsALabel.loop:       ;That is a local label
ThisIsASymbol=10
ThisIsASymbol = 10
ThisIsASymbol equ 10

21.1.4 The relative label

This symbol represents an offset to the start of a program.

label
label:
label	nop
label: nop

21.1.5 The local Label

A local label is only valid between two normal relative labels, thus you cannot reference local labels outside of that scope. Otherwise it works simular as a normal label. There are 2 different prefixes that introduce a local label: <.> and <\> that define 2 different local labels. A special case is the Backward Reference Label that is introduced with <..>. It doesn’t depend on a certain define area between normal labels thus you can only access the symbol if it were defined earlier.

..:
label_0:
.local:
 bra.s .local
label_1:
.local:
 bra.s \local
\local:
 nop
label_end:
..:
 dbra d0,..
..:
 dbra d1,..
..Hello:
 dbra d1,..Hello

21.1.6 The local numerical label

Addionally to the non-numerical local label there are also the numerical labels which are based of 4 digits with the postfix <$>. <BASM> handles the number as a hash key with the consequence that there’s no difference between <001$> and <1$>.

label_0:
123$:	nop
label_1:
123$:	nop

21.1.7 The absolute Symbol

The absolute symbol is defined by a direct value initializing that is initiated by <=>, <equ> or <set>. If you define a symbol by <set> you can change it as often as needed.

value1=2
value2 equ value1*2
value3 set value2

21.1.8 The Register Symbol

The register symbol is defined by ‘equr’ or ‘fequr’ that is used for FPU registers.

Ptr	equr	a1
PI	fequr	fp2
 move.l   (Ptr),d0   ;move.l  (a1),d0
 fmove.x  PI,fp0     ;fmove.x fp2,fp0

21.1.9 The Register List Symbol

The register list symbol is defined by ‘reg’ and represents the register mask for ‘Movem’ and ‘fmovem’. You must not mix FPU and Integer registers with each other in a register list.

mask	reg	d0/d2/d4-d7/a0-a4/a6-a7
mask1	reg	d0-a6
mask2	reg	d0-6
fmask	reg	fp0-fp2/fp4-fp5

21.1.10 The Macro Symbol

By using the command ‘macro’ or ‘cmacro’ after the symbol, the symbol is defined as a macro. The macro block is terminated by the command <endm>. The Macro <cmacro> is case-insensitive and therefore useful to emulate commands that are missing from the core.

Symbol[:] macro
.
.
Symbol[:] endm

21.1.11 Datatypes

The assembler understands 3 distinct datatypes.

• 32Bit Integer
• 96Bit Extended Floating Point
• 96Bit Packed Binary Floating Point

At the moment only integer datatypes are supported in arithmetic arguments so you can only use the FPU datatypes as constants.

+-------------+--------------------+
| Format      | Representation     |
+-------------+--------------------+
+-------------+--------------------+
| Decimal     | 1024               |
+-------------+--------------------+
| Hexadecimal | $400               |
+-------------+--------------------+
| Binary      | %10000000000       |
+-------------+--------------------+
| Ascii       | "OK", 'OK' or `OK` |
+-------------+--------------------+

Furthermore you can use symbols or the character ‘*’ that represents the program counter in arguments. There are limitation in the use of symbols in arguments. For example you can only add or subtract constants from an external label, Floatingpoint Values can only be used as simple constants,… By the postfix ‘k’ after decimal value the value is multply by $1000.

‘Floating Point Format’

+-------------+-------------------------------------+
| Format      | Representation                      |
+-------------+-------------------------------------+
+-------------+-------------------------------------+
| Extended    | '[+,-]3. 145637848298628[e[+,-]123] |
+-------------+-------------------------------------+
| Packed      | ''[+,-]3. 145637848298628[e[+,-]123]|
+-------------+-------------------------------------+

21.1.12 Datatype Conversion

All commands are performed with these 3 datatypes and then converted into the required datatype. For example a 32Bit integer can be converted into 16Bit and 8 Bit; an extended floating point into a double or single floating point. Floating point datatypes are rounded by a convertation. If a rouding error occurs the parser returns with an error.

21.1.13 Datatype Format

Internal Datatype Structure

• Integer

+--------+---------+
| Bit 31 | 30..0   |
+--------+---------+
+--------+---------+
|    S   | Integer |
+--------+---------+

• Single Floating Point

+--------+-----------------+------------+
| Bit 31 | Bits 30..23     | Bits 22..0 |
+--------+-----------------+------------+
+--------+-----------------+------------+
|  Sign  | Biased Exponent |  Fraction  |
+--------+-----------------+------------+

• Double Floating Point

+--------+-----------------+------------+
| Bit 63 | Bits 62..52     | Bits 51..0 |
+--------+-----------------+------------+
+--------+-----------------+------------+
|  Sign  | Biased Exponent |  Fraction  |
+--------+-----------------+------------+

• Extended Floating Point

+--------+-----------------+------------+
| Bit 95 | Bits 94..80     | Bits 62..0 |
+--------+-----------------+------------+
+--------+-----------------+------------+
|  Sign  | Biased Exponent |  Mantisse  |
+--------+-----------------+------------+

• Packed Binary Floating Point

+------+------+------+------+------+------+------+------+
| MEYY | EXP2 | EXP1 | EXP0 | EXP3 | 0000 | 0000 | M016 |
+------+------+------+------+------+------+------+------+
| M015 | M014 | M013 | M012 | M011 | M010 | M009 | M008 |
+------+------+------+------+------+------+------+------+
| M007 | M006 | M005 | M004 | M003 | M002 | M001 | M000 |
+------+------+------+------+------+------+------+------+

• M is the sign (+ or -) of the fraction
• E is the sign (+ or -) of the exponent
• Y are the internal flags for infinity and NAN
• E002-000 are the numbers of the exponent from 2 to 0, EXP3 is used internally.
• M016-000 are the numbers of the fraction from 16 to 0. Each number lies in the range from 0 to 9..

21.1.14 Operations

21.1.15 Operators

+----------+-------------------------------+
| Operator | Function                      |
+----------+-------------------------------+
+----------+-------------------------------+
|   `+'    | 32Bit signed Addition         |
+----------+-------------------------------+
|   `-'    | 32Bit signed Subtraction      |
+----------+-------------------------------+
|   `*'    | 32Bit signed Multiplication   |
+----------+-------------------------------+
|   `/'    | 32Bit signed Division         |
+----------+-------------------------------+
|   '|'    | 32Bit Or                      |
+----------+-------------------------------+
|   `!'    | 32Bit Or                      |
+----------+-------------------------------+
|   `&'    | 32Bit And                     |
+----------+-------------------------------+
|   `^'    | 32Bit Eor                     |
+----------+-------------------------------+
|   `<<'   | logic 32Bit Shift to the left |
+----------+-------------------------------+
|   `>>'   | logic 32Bit Shift to the right|
+----------+-------------------------------+
|   `~'    | 32Bit Not                     |
+----------+-------------------------------+

Basm cares for the operator priorities but be careful while porting Seka Sources because Seka doesn’t care for the priorities.

21.1.16 Functions

The following functions are supported.

• _bitnum(Argument) calculates the bit number of the argument. If this is impossible an error occurs.
• _bitfield(Argument) calculates the bit mask of the argument. If this is impossible an error occurs.
• _extb(Argument) equal to the 680xx command <extb>
• _extw(Argument) equal to the 680xx command <extw>
• _min(Argument[,Argument,…]) calculate the minimum of the argument.
• _max(Argument[,Argument,…]) calculate the maximum of the argument.

21.2 Assembler Commands

Instruction Groups…

21.2.1 Hunk/Link Commands

21.2.1.1 [Label] section Name[,Typ[,[RelocModus,Memtyp]

defines a new logical unit so that the DOS-Loader has the opportuntity to place smaller hunks into free memory blocks. Another use for this command is to set different memory types for the hunk to load gfx data into the chipmem. If you don’t specify the section type it assumes <"",Code,Public>.

• Name = Hunkname
• Hunk type

  ‘CODE’

  starts a code segment.

  ‘DATA’

  starts a data segment.

  ‘BSS’

  starts an undefined data segment.

  ‘DEBUG’

  starts a custom debug segment.

  ‘CUSTOM’

  starts a Custom-Hunk area.

• Reloc-Mode defines the width of the hunk relocation. Default 32Bit

  ‘RELOC16’

  sets the reloc width to 16bit.(V37)

  ‘RELOC32’

  sets the reloc width to 32bit.(Default)

• Memtype defines the memory attributes of the hunk. If you add a ‘_p’, ‘_c’, or ‘_f’ upon the type parameter, you cannot use more memtypes.The memtype ‘DEBUG’ does not allow memory attribute suffixes.

  ‘PUBLIC’

  loads the hunk into the memory with the highest priority. Code Suffix <_p>.

  ‘CHIP’

  loads the hunk into chip memory. Code Suffix <_c>.

  ‘FAST’

  loads the hunk into fast memory. Code Suffix <_f>.

  ‘ADVISORY’

  ignores the hunk if the OS doesn’t understand the type. A kind of Debug-Hunk that can be used by the OS.(V39)

  ‘ATTR=?’

  loads the hunk into the memory with specified memory attributs. (V37)

21.2.1.2 [Label] code [Name[, Memtyp]]

defines a new code hunk and is equivalent to the command ‘section ?,code,?’.

• Name = Hunkname
• Memtype defines the memory attributes for the hunk.

  ‘PUBLIC’

  loads the hunk into the memory with the highest priority. Code Suffix <_p>.

  ‘CHIP’

  loads the hunk into chip memory. Code Suffix <_c>.

  ‘FAST’

  loads the hunk into fast memory. Code Suffix <_f>.

  ‘ADVISORY’

  ignores the hunk if the OS doesn’t understand the type. A kind of Debug-Hunk that can be used by the OS.(V39)

  ‘ATTR=?’

  loads the hunk into the memory with specified memory attributs. (V37)

21.2.1.3 [Label] data [Name[, Memtyp]]

defines a new data hunk and is equivalent to the command ‘section ?,data,?’.

• Name = Hunkname
• Memtype defines the memory attributes for the hunk.

  ‘PUBLIC’

  loads the hunk into the memory with the highest priority. Code Suffix <_p>.

  ‘CHIP’

  loads the hunk into chip memory. Code Suffix <_c>.

  ‘FAST’

  loads the hunk into fast memory. Code Suffix <_f>.

  ‘ADVISORY’

  ignores the hunk if the OS doesn’t understand the type. A kind of Debug-Hunk that can be used by the OS.(V39)

  ‘ATTR=?’

  loads the hunk into the memory with specified memory attributs. (V37)

21.2.1.4 [Label] bss [Name[, Memtyp]]

defines a new BSS hunk and is equivalent to the command ‘section ?,bss,?’.

• Name = Hunkname
• Memtype defines the memory attributes for the hunk.

  ‘PUBLIC’

  loads the hunk into the memory with the highest priority. Code Suffix <_p>.

  ‘CHIP’

  loads the hunk into chip memory. Code Suffix <_c>.

  ‘FAST’

  loads the hunk into fast memory. Code Suffix <_f>.

  ‘ADVISORY’

  ignores the hunk if the OS doesn’t understand the type. A kind of Debug-Hunk that can be used by the OS.(V39)

  ‘ATTR=?’

  loads the hunk into the memory with specified memory attributs. (V37)

21.2.1.5 [Label] cseg [Name[, Memtyp]]

has the same function as the command ‘code’.

21.2.1.6 [Label] dseg [Name[, Memtyp]]

has the same function as the command ‘data’.

21.2.1.7 idnt Name

defines the name of the ‘HUNK_UNIT’ hunk in the object file.

• Name = Hunkname

21.2.1.8 identify Name

defines the name of the actual hunk.

• Name = Hunkname

21.2.1.9 BDebugArg Argument

defines a parameter in env:BDebugProgram. It doesn’t active this function you have to activate by option "-J" in BOPT.

• Argument = Argument Text

21.2.1.10 smalldata [Register]

activates the smalldata mode for the hunk. Optionally, you can also define the smalldata register. Default register is ‘A4’. The program itself must initialize the smalldata register with the address of the smalldata data hunk.

 bopt	w2-			;68020 Addressmode warnings off
 mc68020			;68020 mode activated

 smalldata	a3		;Default is A4!!!
 xref	_LinkerDB		;Special linker symbol

 lea.l	_LinkerDB,a3		;Address of the smalldata data segments
 move.l	#0,(d_test.l,a3)
 move.l	#"TEST",d_test(a3)
 moveq	#0,d0
 tst.b	array(a3,d0.w)
 rts

 section	"__MERGED",BSS	;The smalldata data segments are defined
                                ;the following way
d_test:
 ds.l	1
array:
 ds.b	20

21.2.1.11 xref Symbol[, Symbol…]

imports a symbol so that you can access symbols that were exported by <XDef>. The linker resolves these reference during the link process and creates a program file. If the assembler finds a <XRef> in the source it creates an object file. This decision can be overruled.

• Symbol = Name of the importet symbol.

21.2.1.12 xdef Symbol[, Symbol…]

exports a symbol as global so that other object files can import the symbol by <XRef>. There’s no need to define a symbol before you mark them with <XDef>. If the assembler finds a <XRef> in the source it creates an object file. This decision can be overruled.

• Symbol = Name of the global symbol

21.2.1.13 global Symbol[, Symbol…]

has the same function like <XDef>.

21.2.1.14 public Symbol[, Symbol…]

has the same function like <XDef>.

21.2.1.15 output Name

sets an output filename. If you don’t specify a filename the assembler uses the source filename and adds the appropriate filetype suffix.

• Name = Filename

21.2.1.16 objfile

has the same function like <Output>.

21.2.1.17 exeobj

writes a program file if you wanna overrule the assembler.

21.2.1.18 linkobj

writes an object file if you wanna overrule the assembler.